1. Field of the Invention
The present invention relates to a binary code phase offset calculation method of a mobile communication system.
2. Discussion of the Related Art
Among the codes with q elements which are used for transmitting information in a CDMA or CTDMA of a digital communication system, a binary code whose q is 2 is generally used. The analog signals such as voice signals or image signals are converted into a binary code by an analog to digital converter. This binary code is modulated according to a frequency translation to be transmitted by a radio or wire communication system. The receiver recovers the analog signal from the modulated binary code. Thus, the binary code is not only transmitted as information itself but also used as a spread spectrum code in the code division multiple access system or the code time division multiple access system of the mobile communication.
To increase the capacity of cellular mobile communication, the digital cellular mobile communication using the global system for mobile (GSM) communication has been commercialized in European countries and the TDMA and CDMA systems have commercially been used in the USA. The T1A/ELA/IS95CDMA system developed by Qualcomm of the USA is used as the standard communication system of Korea.
For the CDMA systems mentioned above, a code having a special autocorrelation function is used as a spread code and it is also used for synchronization of a receiver and cryptography, etc.
In the CDMA system, each base station is assigned to its own phase offset and is identified by the phase offset. Therefore, the soft handoff which matches the phase offsets between the pseudo noise (PN) signals each of which belonging to each base station is possible and a mobile station belonging to one cell uses the phase difference of identical signals received from other base stations in order to identify the base stations from which the signals are transmitted.
According to a conventional CDMA system, each of the received PN spread codes is in one to one correspondence with a reference PN spread code having a length of 215 bits. Since the method for acquiring the phase offset information of the PN spread code to identify each base station is used in the conventional CDMA system, the amount of calculation for calculating the phase offset is very large and the hardware complexity for the system is also high. It is practically impossible for a terminal or a mobile station to process the large amount of calculations for the phase offset information of the PN spread code. Therefore, the phase offset of the PN spread code is calculated at each base station and then transmitted to each terminal by a modulated signal.
In the CDMA system of the International Telecommunication Standardization Sector (ITSS), the Barker code with a length of 13 is used as its spread code, and many subscribers using the same frequency bandwidth in one base station is assigned to the identical Barker spread code but each code assigned to each subscriber has a different phase offset or time offset from one another. In other words, the information of the phase offset information is the same as the channel number assigned to each subscriber and therefore each subscriber is identified according the phase offset information.
However, the CDMA system of the ITSS, as the other conventional CDMA system described beforehand, uses a modulation method by which the offset information is modulated with a transmission signal in a base station and the modulated signal is transmitted from the base station to a terminal.
A conventional phase synchronization method of a binary code is described in a paper of Acquisition Time Performance of PN Spread Spectrum System, by C.C. Chen published in IEEE Transaction on Communication Vol COM-25 NO.8 PP778-784, August 1997.
In the phase synchronization method of binary code disclosed in the paper, as shown in FIG. 1, a received pseudo noise (PN) code is multiplied with a local PN code provided from the stored local PN code updater 4 in the multiplier 1. The output of the multiplier 1 is integrated by the integrator 2 for the dwell time xcfx84d. The output of the integrator 2 is the correlation value. This correlation value is compared with a predetermined threshold value in the threshold comparator 3. When the correlation value is not larger than the threshold value, the comparator 3 transmits a control signal to the local PN code updater 4 to update the local PN code so that the local PN code is generated in advance or delayed by one chip interval or a half chip interval. The output of the updated local PN code is multiplied by the received PN code in the multiplier 1. By performing repeatedly this procedure until the correlation value generated from the integrator 2 is larger than the threshold value, the acquisition of PN code, that is a coarse synchronization, is achieved. If the PN code acquisition is achieved and therefrom the correlation value obtained from the integrator 2 is larger than the threshold value, the PN code tracking, that is a fine synchronization, is performed.
When the total number q of the cell to be searched during one period satisfies q greater than  greater than 1, the average synchronization time of the PN code synchronization method is                                                         T              _                        acq                    =                                                                      (                                      2                    -                                          P                      D                                                        )                                ⁢                                  (                                      1                    +                                          KP                      FA                                                        )                                                            2                ⁢                                  P                  D                                                      ⁢                          (                              q                ⁢                                  xe2x80x83                                ⁢                                  τ                  D                                            )                                      ,                            [                  equation          ⁢                      xe2x80x83                    ⁢          1                ]            
where q equals the length of the PN code or a multiple of the length. For example, q equals the length of the PN code when the local PN code is updated by one chip interval and q is twice the length of the PN code when the local PN code is updated by a half chip interval. PD is a signal detection probability and PFA is a false alarm probability. K is an average penalty according to the false alarm.
The average time from the time at which the system enters the tracking loop by the false alarm and to the time at which the system escapes from the loop is Kxcfx84D.
In the mobile communication system used in a conventional CDMA system described in detail above, the mobile station (terminal) cannot acquire the phase offset information by itself if the phase offset information concerned with its neighbor cells is not provided by the base station. Therefore, the mobile station cannot simultaneously demodulate both the signal received from the base station to which the mobile station belongs and the signal received from other base stations. Furthermore, when a mobile station is going to move out of the area covered by its present base station and enter another area covered by another base station having a different phase offset, the mobile station cannot match the phase offset of the present base station with the phase offset of the spread code of the new base station. Therefore, the mobile station cannot have a handoff function for itself and the traffic of the base station is increased. Even in the CDMA system, since a subscriber cannot acquire the phase offset being used by the other subscriber without the help of the base station and cannot even pick up a phase offset or a channel which is not occupied by other subscribers, the conventional method has a problem of an increased traffic in the base station.
Since the conventional binary code synchronization method performs repeatedly the procedure that updates the local PN code by increasing or decreasing the code by one chip or a half chip interval until the correlation value is larger than the threshold value, the conventional method has a problem of a long acquisition time.
Accordingly, the present invention is directed to solve the problems of the conventional techniques described above.
The present invention provides a binary code phase offset calculation method that the binary code phase offset is easily calculated and therefore the calculation is done in the subscriber terminal.
The present invention also provides a synchronization method of the binary code that greatly reduces the acquisition time by using the binary code phase offset.
Furthermore, the present invention provides an error detection method of the binary code that determines whether or not an error is in a received binary code by using the binary code phase offset.
To achieve the present invention, as embodied and broadly described, the binary code phase offset calculation method according to the present invention includes the first step of receiving a cyclic binary code Ti(C) having a period n, the second step of setting an accumulator function weight value of the binary code and then calculating the binary code weighted accumulator value by applying said weight value to said binary code, the third step of performing the phase shift of the binary code weighted accumulator value, and the fourth step of calculating the binary code phase offset by performing a modulo n on the result of the third step of performing.
Another embodiment of the binary code-phase offset calculation method according to the present invention includes the step of receiving two identical binary codes TX(C) and TY(C) having the same period n and different phase offsets X and Y, respectively, the step of setting two binary code accumulator function weights s and l and calculating two binary code weighted accumulator values As(TX(C)) and Al(TY(C)) according to the two weights s and l, the step of setting an arithmetic inverse a* corresponding to a*(nxe2x88x922k)=1(mod n) if said two binary codes are {xe2x88x921, 1} and setting an arithmetic inverse a* corresponding to a*(nxe2x88x92k)=1(mod n) if said two binary codes are {xe2x88x921, 1}, the step of calculating the difference a*As(TX(C))xe2x88x92a*Al(TY(C)) after performing the phase shift on the two weighted accumulator values As(TX(C)) and Al(TY(C)), and the step of generating the two binary code phase offset X-Y by adding said difference and the weight difference lxe2x88x92s and then by performing a modulo n operation on the result of the step of adding.
The binary code error detection method according to the present invention includes the step of receiving a binary code Ti(Ĉ) with a period n where n and i are integers, T is a cyclic operator and Ĉ is a binary code, and then calculating a binary code accumulator value, the step of performing the phase shift of said accumulator value, and the step of deciding whether or not a number of specific elements of the received binary code is k after a modulo n operation is performed on the result of said step of performing and whether or not the value of the operation is 1 is determined.
A binary code synchronization method using a phase offset according to the present invention includes the step of calculating a phase offset by calculating an accumulator weighted value Al(Ti+j(Ĉ)) over the one period in which the weight of the received cyclic binary code Ti+j(Ĉ) with a period n is l, where i, j and l are integers, Ĉ is a received binary code and T is a cyclic operator, an accumulator weighted value Al(Ti(Ĉ)) of the cyclic binary code Ti(C) with a period n of a local PN code generator where C is a binary code of the local PN code generator without having any error, respectively, by calculating the difference between the two accumulator weighted values, by calculating the phase shift value after performing a phase shift on the difference, and by performing a modulo n on the phase shift value, the step of calculating an added value             C      ^        ⁢          (      1      )        =            ∑              i        =        0                    n        -        1              ⁢                  C        ^            i      
over the one period of the received binary code Ti+j(Ĉ), performing the phase shift on the added value, performing a modulo n on the result of said step of performing and determining whether or not the result of said performing a modulo n operation is 1, the step of repeatedly performing both the step of calculating the received binary code phase offset and the step of checking the said modulo n operation value until the modulo n operation value becomes 1 if the modulo n operation value is not 1, the step of performing a cyclic shift on the phase of the local PN binary code by the calculated phase offset if the modulo n operation value is 1 and then switching to a tracking mode which is a fine synchronization, and the step of repeatedly performing all said steps in sequence from the first step until the synchronization is completed in a predetermined time if the synchronization is not achieved in the predetermined time after switching to the tracking mode.
The terminologies to be used in the present invention are defined as follows:
The binary code C has a period n. k is a number of the elements 1 or xe2x88x921 included in the binary code. When the binary code consists of two elements 0 and 1, the binary code satisfies the condition that n and k are prime to each other, i.e. gcd(n,k)=1. When the binary code consists of two elements xe2x88x921 and 1, the binary code satisfies the condition that n and 2k are prime to each other, i.e. gcd(n,2k)=1.
The binary code c which is n-tuple and the right cyclic operator T are defined as                               C          =                      (                                          C                0                            ,                              C                1                            ,                              ⋯                ⁢                                  xe2x80x83                                ⁢                                  C                                      n                    -                    2                                                              ,                              C                                  n                  -                  1                                                      )                          ⁢                  
                ⁢                              T            ⁡                          (              C              )                                =                      (                                          C                                  n                  -                  1                                            ,                              C                0                            ,                              C                1                            ,                              ⋯                ⁢                                  xe2x80x83                                ⁢                                  C                                      n                    -                    2                                                                        )                          ⁢                  
                ⁢                  xe2x80x83                ⁢        ⋮        ⁢                  
                ⁢                                            T              i                        ⁡                          (              C              )                                =                      (                                          C                                  n                  -                  i                                            ,                              C                                  n                  -                  i                  +                  1                                            ,                              ⋯                ⁢                                  xe2x80x83                                ⁢                                  C                                      n                    -                    i                    -                    2                                                              ,                              C                                  n                  -                  i                  -                  1                                                      )                          ⁢                  
                ⁢                  xe2x80x83                ⁢        ⋮        ⁢                  
                ⁢                                                            T                                  n                  -                  1                                            ⁡                              (                C                )                                      =                          (                                                C                  1                                ,                                  C                  2                                ,                                  ⋯C                                      n                    -                    i                                                  ,                                  C                  0                                            )                                ,          and                ⁢                  "IndentingNewLine"                ⁢                                            if              ⁢                              xe2x80x83                            ⁢              i                        =                          j              ⁢                              xe2x80x83                            ⁢                              (                                  mod                  ⁢                                      xe2x80x83                                    ⁢                  n                                )                                              ,          then                ⁢                  
                ⁢                                                                                                                        T                      i                                        ⁡                                          (                      C                      )                                                        =                                                                                    T                        j                                            ⁡                                              (                        C                        )                                                              =                                          (                                                                        C                                                      n                            -                            i                                                                          ,                                                  C                                                      n                            -                            i                            +                            1                                                                          ,                                                  ⋯                          ⁢                                                      xe2x80x83                                                    ⁢                                                      C                                                          n                              -                              i                              -                              2                                                                                                      ,                                                  C                                                      n                            -                            i                            -                            1                                                                                              )                                                                      ,                                                    ⁢                  
                ⁢                              where            ⁢                          xe2x80x83                        ⁢            i            ⁢                          xe2x80x83                        ⁢            and            ⁢                          xe2x80x83                        ⁢            j            ⁢                          xe2x80x83                        ⁢            are            ⁢                          xe2x80x83                        ⁢            integers            ⁢                          xe2x80x83                        ⁢            and            ⁢                          xe2x80x83                        ⁢                                          T                0                            ⁡                              (                C                )                                              =                      C            .                                              [                  equation          ⁢                      xe2x80x83                    ⁢          2                ]            
The code Tj(C) is defined as a polynomial
C(x)=Cnxe2x88x92j+Cnxe2x88x92j+1x - - - +Cnxe2x88x92jxe2x88x921xnxe2x88x921xe2x80x83xe2x80x83[equation 3]
The accumulator function whose weight value is 1 is defined as
Al(Tj(C))=d/dxxlC(x)|x=1=lCnxe2x88x92j+(l+1)Cnxe2x88x92j+1 . . . +(l+nxe2x88x921)Cnxe2x88x92jxe2x88x921,xe2x80x83xe2x80x83[equation 4]
where 1 is an arbitrary integer. If two numbers l and s satisfy the condition that l=s(mod n), then Al(Tj(C))=As(Tj(C)) (mod n).
If the element of the binary code C of n tuple is {xe2x88x921, 1}, the accumulator function Al(Tj(C)) is represented as Al1(C). If the element of the binary code C is {0, 1}, the accumulator function Al(Tj(C)) is represented as Al0(C). It the element of the binary code C may be one of the two cases the subscripted index is omitted.
If the binary code C satisfies the condition that Al(Tj(C))=0(mod n), it is defined as a reference code of the accumulator function with a weight l or a zero offset code.
If the binary code C consists of the element {0, 1}, a* is selected as an arithmetic inverse of nxe2x88x92k of the a*(nxe2x88x92k)=1(modulo n).
If the binary code C consists of the element {xe2x88x921, 1}, a* is selected as an arithmetic inverse of nxe2x88x922k of the a*(nxe2x88x922k)=1(modulo n).
If the weight l is 1, equation 4 becomes as                                                                                           A                  l                                ⁡                                  (                                                            T                      j                                        ⁡                                          (                      C                      )                                                        )                                            =                              xe2x80x83                            ⁢                                                ⅆ                                      ⅆ                    x                                                  ⁢                                  x                  l                                ⁢                                  C                  ⁡                                      (                    x                    )                                                  ⁢                                  "LeftBracketingBar"                                      x                    =                    1                                                                                                                          =                              xe2x80x83                            ⁢                                                ⅆ                                      ⅆ                    t                                                  ⁢                                  (                                                            xC                                              n                        -                        j                                                              +                                                                  x                        2                                            ⁢                                              C                                                  n                          -                          j                          +                          1                                                                                      +                    ⋯                    +                                                                                                                                                            xe2x80x83                                ⁢                                                                                                    x                                                  n                          -                          1                                                                    ⁢                                              C                                                  n                          -                          j                          -                          2                                                                                      +                                                                  x                        n                                            ⁢                                              C                                                  n                          -                          j                          -                          1                                                                                                      )                                            ⁢                              "LeftBracketingBar"                                  x                  =                  1                                                                                                        =                              xe2x80x83                            ⁢                                                C                                      n                    -                    j                    -                    1                                                  +                                  (                                                            C                                              n                        -                        j                        -                        1                                                              +                                          C                                              n                        -                        j                        -                        2                                                                              )                                +                                                                                                        xe2x80x83                            ⁢                                                (                                                            C                                              n                        -                        j                        -                        1                                                              +                                          C                                              n                        -                        j                        -                        2                                                              +                    ⋯                    +                                          C                                              n                        -                        j                        +                        1                                                                              )                                +                                                                                                        xe2x80x83                            ⁢                              (                                                      C                                          n                      -                      j                      -                      1                                                        +                                      C                                          n                      -                      j                      -                      2                                                        +                  ⋯                  +                                      C                                          n                      -                      j                      +                      1                                                        +                                      C                                          n                      -                      j                                                                      )                                                                        [                  equation          ⁢                      xe2x80x83                    ⁢          5                ]            
The following equation is derived from the equations 4 and 5.
Al(Tj(C))=Al(Tj(C))+(lxe2x88x921)C(1)xe2x80x83xe2x80x83[equation 6]
When a number of the 0, 1 or xe2x88x921 elements included in each one of the binary codes C and Ĉ is k and {circumflex over (k)}, respectively, and the element included in the binary code C satisfies the condition that (2k,n)=1 when Cixcex5{xe2x88x921, 1} and satisfies the condition that (k, n)=1 when Cixcex5{0, 1}, kxe2x89xa0{circumflex over (k)}, and "xgr" and n are prime to each other, the following equation is obtained.
a*[Ai(T"xgr"(Ĉ))xe2x88x92Ai(Ĉ)]xe2x89xa0xcex5(mod n) a*Ĉ(1)xe2x89xa01(mod n),xe2x80x83xe2x80x83[equation 7]
where n is an integer and       C    ^    =            ∑              i        =        0                    n        -        1              ⁢                  C        ^            i      
a* is an arithmetic inverse of a modulo n.
The reason is as follows.
Each one of the binary codes C and Ĉ is defined as
C=(C0, C0, . . . , Cnxe2x88x921)
Ĉ=(Ĉ0, Ĉ1, . . . , Ĉnxe2x88x921)
When k and k represent a number of the elements 0, 1 or xe2x88x921 included in C and Ĉ, respectively, kxe2x89xa0{circumflex over (k)}. Therefore, it is possible to write that {circumflex over (k)}=k+kxe2x80x2. Since 1 less than k and {circumflex over (k)} less than nxe2x88x921, kxe2x80x2xe2x89xa00 and |kxe2x80x2|xe2x89xa6nxe2x88x922.
When the element included in the binary code C is Cixcex5{xe2x88x921, 1}, the condition (2k, n)=1 is satisfied and n is an odd number.
Since a* is an arithmetic inverse of xe2x88x922k modulo n, xe2x88x922ka*=1(mod l).
This means (xe2x88x922k a*,n)=1 and therefore (a*,n)=1 according to (2k,n)=1.
Therefore, the phase offset between the binary code C and the identical binary code T86(Ĉ) on which the cyclic phase shift is done by "xgr" times, is                                                                         a                *                                  [                                                                                                              A                          1                                                i                                            ⁡                                              (                                                                              T                            ξ                                                    ⁡                                                      (                                                          C                              ^                                                        )                                                                          )                                                              -                                                                                            A                          1                                                i                                            ⁡                                              (                                                  C                          ^                                                )                                                                              ]                                            =                              a                *                ξ                ⁢                                  xe2x80x83                                ⁢                                  C                  ^                                                                                                        =                              a                *                                  (                                                            -                      2                                        ⁢                                          k                      ^                                        ⁢                                          xe2x80x83                                        ⁢                    ξ                                    )                                ⁢                                  xe2x80x83                                ⁢                                  (                                      mod                    ⁢                                          xe2x80x83                                        ⁢                    n                                    )                                                                                                        =                              a                *                                  (                                                            -                      2                                        ⁢                                          ξ                      ⁡                                              (                                                  k                          +                                                      k                            xe2x80x2                                                                          )                                                                              )                                ⁢                                  xe2x80x83                                ⁢                                  (                                      mod                    ⁢                                          xe2x80x83                                        ⁢                    n                                    )                                                                                                                        =                                                      (                                          ξ                      +                                              b                        ⁢                                                  xe2x80x83                                                ⁢                                                  k                          xe2x80x2                                                                                      )                                    ⁢                                      xe2x80x83                                    ⁢                                      (                                          mod                      ⁢                                              xe2x80x83                                            ⁢                      n                                        )                                                              ,                                                          [                  equation          ⁢                      xe2x80x83                    ⁢          8                ]                                          where          ⁢                      xe2x80x83                    ⁢          b                =                  –          ⁢                      xe2x80x83                    ⁢          2          ⁢          ξ          ⁢                      xe2x80x83                    ⁢          a          *                                    (                              mod                ⁢                                  xe2x80x83                                ⁢                n                            )                        .                                              xe2x80x83            
Since the necessary condition for
"xgr"a*Ĉxe2x89xa0"xgr"(mod n)
is that a*Ĉ(1)xe2x89xa11[mod n/("xgr", n)xe2x89xa11(mod n), the equation a*Ĉ(1)xe2x89xa01(mod n) is established from the equation "xgr"a*Ĉ(1)xe2x89xa0"xgr"(mod n). As the result, (a*,n)=1 and kxe2x80x2 is an integer satisfying the condition that kxe2x80x2xe2x89xa00 and |kxe2x80x2|xe2x89xa6nxe2x88x922.
Therefore, if ("xgr", n)=1, then (b, n)=1, b kxe2x80x2xe2x89xa00(mod n), a*"xgr"Ĉ(1)=("xgr"b kxe2x80x2)(mod n), and a*Ĉ(1)xe2x89xa01(mod n).
As the result, equation 8 is established for the case that the element included in the binary code C is Cxcex5{xe2x80x941, 1}.
According to the same procedure, equation 8 is established in the case that the element included in the binary code C is Cxcex5{0, 1}.
Additional features and advantages of the invention will be set forth in the description which follows, and in part will be apparent from the description, or may be learned by practice of the invention. The objectives and other advantages of the invention will be realized and attained by the structure particularly pointed out in the written description and claims hereof as well as the appended drawings.